home *** CD-ROM | disk | FTP | other *** search
/ Garbo / Garbo.cdr / mac / source / music4c.sit / Music4C Folder / Sources Folder / MacInterface2.c < prev    next >
Text File  |  1990-09-09  |  10KB  |  391 lines
  1. /*
  2. * ⌐ Graeme Gerrard 1990
  3. * Faculty of Music, University of Melbourne
  4. * Parkville Victoria 3052 Australia.
  5. *
  6. * ARPANET: grae@murdu.ucs.unimelb.edu.au
  7. * telephone: (613) 344 4127, Fax: (613) 344 5346
  8. */
  9.  
  10.  
  11. #include    "Music4C.h"
  12. #include    "Music4C_Prototype.h"
  13. #include    "Synthesis_Time.h"
  14.  
  15.  
  16. void            prepareSDfile(double);
  17. void            prepareAIFFfile(double, int);
  18. Boolean            pass3(void);
  19. void            FixHeaderInfo(void);
  20. void            tell_mem(void);
  21. Boolean            Mac_write3(float *, float);
  22. void            readBack(void);
  23. DialogPtr       thePass3DialogPtr;
  24.  
  25. extern void   D_Synthesis_Progress(void);
  26.  
  27. static pascal char  MyFilter (DialogPtr   theDialog,  EventRecord   *theEvent,  short  *itemHit);
  28. static void  Refresh_Dialog(DialogPtr    GetSelection);
  29. void    DisplayDialog(DialogPtr);
  30.  
  31.  
  32. #define  I_Cancel   1
  33. #define  I_OK   1
  34.  
  35. static void  Refresh_Dialog(GetSelection) 
  36.     DialogPtr    GetSelection;
  37. { 
  38.     Rect    tempRect;
  39.     short    DType;
  40.     Handle    DItem;
  41.  
  42.     GetDItem(GetSelection,I_OK, &DType, &DItem, &tempRect);
  43.     PenSize(3, 3);
  44.     InsetRect(&tempRect, -4, -4);
  45.     FrameRoundRect(&tempRect, 16, 16); 
  46.     PenSize(1, 1); 
  47.     
  48. } 
  49.  
  50. /* ======================================================== */
  51.  
  52. static        Handle        aHand;
  53. extern        OSErr        theErr;
  54. extern        Boolean        AIFFoddByte;
  55. extern        int            nrec;
  56. static        Rect        prgBox;
  57. extern        double        TotalDuration;
  58. extern        int            nchnls;
  59. extern        double        srate;
  60. static        double        barStep;
  61. static        int            NumberOfRecordsToWrite;
  62. static        int            *theIbuf;
  63. static        double        theScalefactor;
  64. static        DialogPtr   GetSelection;
  65. static        int                type;
  66.  
  67.  
  68. Boolean    MAC_do_pass3()
  69. {
  70.     Rect            tempRect;
  71.     short            itemHit;
  72.     long            nTicks;
  73.     long            startTick;
  74.     long            TotalTicks;
  75.     char            theChar;
  76.     extern            CursHandle    theCursor;
  77.     extern            ioParam        myIOParmBlk;
  78.     extern            int            SFoutputType;
  79.     extern            Boolean        CreateSoundFile;
  80.     extern            long        TotalSamps;
  81.     extern            Str255        theMess1;
  82.     Boolean            result;
  83.     
  84.      
  85.     GetSelection = GetNewDialog(PASS3_DIALOG, NIL, (WindowPtr)-1);
  86.     thePass3DialogPtr = GetSelection;
  87.     
  88.     tempRect.top = GetSelection->portRect.top;
  89.     tempRect.left = GetSelection->portRect.left;
  90.     tempRect.bottom = GetSelection->portRect.bottom;
  91.     tempRect.right = GetSelection->portRect.right;
  92.     tempRect.top = -GetSelection->portBits.bounds.top;
  93.     tempRect.left = ((screenBits.bounds.right - screenBits.bounds.left) - (tempRect.right - tempRect.left)) / 2;
  94.     MoveWindow(GetSelection, tempRect.left, tempRect.top, TRUE);
  95.  
  96.     NumberOfRecordsToWrite = (int) (((TotalDuration * nchnls) * (srate / SAMPBUFSZ)) + 0.5);
  97.     GetDItem(GetSelection, 2, &type, &aHand, &prgBox);
  98.     barStep = (double)(prgBox.right - prgBox.left ) / (double)NumberOfRecordsToWrite;
  99.  
  100.     theCursor = GetCursor(watchCursor);
  101.     SetCursor(*theCursor);
  102.     
  103.     /* are we dealing with a SD file ? */
  104.     if ( CreateSoundFile ) {
  105.         if ( SFoutputType == SD ) {
  106.             myIOParmBlk.ioPosMode = fsAtMark;
  107.             myIOParmBlk.ioPosOffset = NIL;
  108.             myIOParmBlk.ioCompletion = NIL;
  109.             if ( nchnls == 1 )
  110.                 prepareSDfile(TotalDuration);
  111.             theScalefactor = SAMPMAX; /* not actually used */
  112.             theIbuf = (int *)NewPtr(sizeof(int) * SAMPBUFSZ);
  113.         }
  114.         else if ( SFoutputType == AIFF ) {
  115.             prepareAIFFfile(TotalDuration, nchnls);
  116.             theScalefactor = SAMPMAX; /* not actually used */
  117.             theIbuf = (int *)NewPtr(sizeof(int) * SAMPBUFSZ);
  118.         }
  119.         else if ( SFoutputType == INT16 ) {
  120.             theIbuf = (int *)NewPtr(sizeof(int) * SAMPBUFSZ);
  121.             theScalefactor = 1.0;
  122.             myIOParmBlk.ioReqCount =  TotalDuration * nchnls * srate * sizeof(int);
  123.             myIOParmBlk.ioCompletion = NIL;
  124.             if ( (theErr = PBAllocContig(&myIOParmBlk, FALSE)) != noErr ) {
  125.                 if ( theErr == dskFulErr ) {
  126.                     if ( (theErr = PBAllocate(&myIOParmBlk, FALSE)) != noErr ) {
  127.                         PstringCopy((char *)theMess1, "\pCan't allocate disk space for sound file");
  128.                         OSError(theMess1, NIL, NIL);
  129.                     }
  130.                 }
  131.             }
  132.         }
  133.     }
  134.     
  135.     startTick = TickCount();
  136.     FlushEvents(everyEvent,0);
  137.     ShowWindow(GetSelection);
  138.     SelectWindow(GetSelection);
  139.     SetPort(GetSelection);
  140.     DisplayDialog(GetSelection);
  141.     result = pass3();
  142.     DisposDialog(GetSelection);
  143.     
  144.     /* all finished */
  145.     if ( SFoutputType == AIFF ) {
  146.         if ( AIFFoddByte ) {
  147.             myIOParmBlk.ioReqCount = 1L;
  148.             theChar = '\0';
  149.             myIOParmBlk.ioBuffer = (Ptr)theChar;
  150.             if ( (theErr = PBWrite(&myIOParmBlk, FALSE)) != noErr ) {
  151.                 PstringCopy((char *)theMess1, "\pError writing to sample file");
  152.                 OSError(theMess1, NIL, NIL);
  153.             }
  154.         }
  155.         FixHeaderInfo();
  156.     }
  157.     TotalTicks = TickCount() - startTick;
  158.     NumToString((TotalTicks / 60), theMess1);
  159.     InitCursor();
  160.     ParamText(theMess1, NIL, NIL, NIL);
  161.     D_Synthesis_Time();
  162.     if ( result )
  163.         return(TRUE);
  164.     else
  165.         return(FALSE);
  166. }
  167.  
  168. Boolean    Mac_write3(theSamps, synthTime)
  169.     float    *theSamps;
  170.     float    synthTime;
  171. {
  172.     register        i;
  173.     extern            Boolean        CreateSoundFile;
  174.     extern            int            wrote_rec;
  175.     extern            ioParam        myIOParmBlk;
  176.     long            nBytes;
  177.     EventRecord        event;
  178.     long            Number;
  179.     long            aLong;
  180.     char            c;
  181.     Rect            aRect;
  182.     int                type;
  183.     int                rightPoint;
  184.     int                *Iptr;
  185.     float            *sp;
  186.     double            x;
  187.     long            nSamps;
  188.     Point            where, P1, P2, P3;
  189.     Rect            tempRect;
  190.     short            DType;
  191.     short            itemHit;
  192.     Handle            DItem;
  193.     extern            float        MaxSample;
  194.     extern            float        MinSample;
  195.     long    fTicks;
  196.     
  197.     nrec++;
  198.     nBytes = (long)SAMPBUFSZ * sizeof(float);
  199.  
  200.     if (CreateSoundFile) {
  201.         myIOParmBlk.ioCompletion = NIL;
  202.         switch(SFoutputType ) {
  203.             case    FLOAT:
  204.                 myIOParmBlk.ioReqCount = nBytes;
  205.                 myIOParmBlk.ioBuffer = (Ptr)theSamps;
  206.                 if ( (theErr = PBWrite(&myIOParmBlk, FALSE)) != noErr ) { 
  207.                     PstringCopy((char *)theMess1, "\pError writing to sample file");
  208.                     OSError(theMess1, NIL, NIL);
  209.                 }
  210.                 if ( myIOParmBlk.ioActCount != nBytes ) {
  211.                     PstringCopy((char *)theMess1, "\pError writing to sample file wrote wrong number of bytes");
  212.                     OSError(theMess1, NIL, NIL);
  213.                 }                
  214.                 break;
  215.             case    SD:
  216.             case    SD2:
  217.                 nSamps = SAMPBUFSZ;
  218.                 nBytes = (long)SAMPBUFSZ * sizeof(int);
  219.                 for ( i = 0, Iptr = theIbuf, sp = theSamps; i < nSamps; i++ ) {
  220.                     x = *sp++;
  221.                     if ( x < MinSample )
  222.                         MinSample = x;
  223.                     if ( x > MaxSample )
  224.                         MaxSample = x;
  225.                     *Iptr++ = (int)x;
  226.                 }
  227.                 /* write it out */
  228.                 myIOParmBlk.ioReqCount = (long)(nSamps * sizeof(int));
  229.                 myIOParmBlk.ioBuffer = (Ptr)theIbuf;
  230.                 if ( (theErr = PBWrite(&myIOParmBlk, FALSE)) != noErr ) { 
  231.                     PstringCopy((char *)theMess1, "\pError writing to sample file");
  232.                     OSError(theMess1, NIL, NIL);
  233.                 }
  234.                 if ( myIOParmBlk.ioActCount != myIOParmBlk.ioReqCount ) {
  235.                     PstringCopy((char *)theMess1, "\pError writing to sample file wrote wrong number of bytes");
  236.                     OSError(theMess1, NIL, NIL);
  237.                 }
  238.                 break;
  239.             case    AIFF:
  240.                 nSamps = SAMPBUFSZ;
  241.                 TotalSamps += nSamps;
  242.                 nBytes = (long)SAMPBUFSZ * sizeof(int);
  243.                 for ( i = 0, Iptr = theIbuf, sp = theSamps; i < nSamps; i++ ) {
  244.                     x = *sp++;
  245.                     if ( x < MinSample )
  246.                         MinSample = x;
  247.                     if ( x > MaxSample )
  248.                         MaxSample = x;
  249.                     *Iptr++ = (int)x;
  250.                 }
  251.                 /* write it out */
  252.                 myIOParmBlk.ioReqCount = (long)(nSamps * sizeof(int));
  253.                 myIOParmBlk.ioBuffer = (Ptr)theIbuf;
  254.                 if ( (theErr = PBWrite(&myIOParmBlk, FALSE)) != noErr ) { 
  255.                     PstringCopy((char *)theMess1, "\pError writing to sample file");
  256.                     OSError(theMess1, NIL, NIL);
  257.                 }
  258.                 if ( myIOParmBlk.ioActCount != myIOParmBlk.ioReqCount ) {
  259.                     PstringCopy((char *)theMess1, "\pError writing to sample file wrote wrong number of bytes");
  260.                     OSError(theMess1, NIL, NIL);
  261.                 }
  262.                 break;
  263.             case    INT16:
  264.                 nSamps = SAMPBUFSZ;
  265.                 nBytes = (long)SAMPBUFSZ * sizeof(int);
  266.                 for ( i = 0, Iptr = theIbuf, sp = theSamps; i < nSamps; i++ ) {
  267.                     x = *sp++;
  268.                     if ( x < MinSample )
  269.                         MinSample = x;
  270.                     if ( x > MaxSample )
  271.                         MaxSample = x;
  272.                     *Iptr++ = (int)x;
  273.                 }
  274.                 /* write it out */
  275.                 myIOParmBlk.ioReqCount = (long)(nSamps * sizeof(int));
  276.                 myIOParmBlk.ioBuffer = (Ptr)theIbuf;
  277.                 if ( (theErr = PBWrite(&myIOParmBlk, FALSE)) != noErr ) { 
  278.                     PstringCopy((char *)theMess1, "\pError writing to sample file");
  279.                     OSError(theMess1, NIL, NIL);
  280.                 }
  281.                 if ( myIOParmBlk.ioActCount != myIOParmBlk.ioReqCount ) {
  282.                     PstringCopy((char *)theMess1, "\pError writing to sample file wrote wrong number of bytes");
  283.                     OSError(theMess1, NIL, NIL);
  284.                 }
  285.                 break;
  286.         }
  287.     }
  288.     SetPort(GetSelection);
  289.     rightPoint = prgBox.left + (nrec * barStep);
  290.     if ( rightPoint > prgBox.right )
  291.         rightPoint = prgBox.right;
  292.     if ( nrec == NumberOfRecordsToWrite )
  293.         rightPoint = prgBox.right;
  294.         
  295.     SetRect(&aRect, prgBox.left, prgBox.top, rightPoint, prgBox.bottom);
  296.     FillRect(&aRect, gray);
  297. /*    Refresh_Dialog(GetSelection); */
  298.     
  299.     wrote_rec = 1;
  300.     GetNextEvent(everyEvent, &event);
  301.     if ( IsDialogEvent(&event) ) {
  302.         if ( DialogSelect(&event, &GetSelection, &itemHit)) {
  303.             if ( itemHit == 1) {
  304.                 SetRect(&tempRect, 185, 72, 265, 92 );
  305.                 InsetRect(&tempRect, 1, 1 );
  306.                 InvertRoundRect(&tempRect, 8, 8 );
  307.                 Delay(30L, &fTicks);
  308.                 return(FALSE);
  309.             }
  310.         }
  311.     }
  312.     return(TRUE);
  313. }
  314.  
  315.  
  316. void    tell_mem()
  317. {
  318.     long    freemem1;
  319.     long    stackspace1;
  320.     Size    maxmem1;
  321.     long    maxblock1;
  322.     long    aLong1, anotherLong1;
  323.     Size    aSize1;
  324.     THz        syszone1;
  325.     Size    totalmem1;
  326.     
  327.     long    freemem2;
  328.     long    stackspace2;
  329.     Size    maxmem2;
  330.     long    maxblock2;
  331.     long    aLong2, anotherLong2;
  332.     Size    aSize2;
  333.     THz        syszone2;
  334.     Size    totalmem2;
  335.     
  336.     
  337.     freemem1 = FreeMem();
  338.     maxblock1 = MaxBlock();
  339.     maxmem1 =  (long)MaxMem(&aSize1);
  340.     stackspace1 = StackSpace();
  341.     syszone1 = SystemZone();
  342.     anotherLong1 = (long)syszone1;
  343.     
  344.     totalmem1 = (long)CompactMem(maxSize);
  345.  
  346.     freemem2 = FreeMem();
  347.     maxblock2 = MaxBlock();
  348.     maxmem2 =  (long)MaxMem(&aSize2);
  349.     stackspace2 = StackSpace();
  350.     syszone2 = SystemZone();
  351.     anotherLong2 = (long)syszone2;
  352.     totalmem2 = (long)CompactMem(maxSize);
  353. }
  354.  
  355.  
  356.  
  357. void    readBack()
  358. {
  359.     extern    float    *SampsPtr;
  360.     long    nBytes;
  361. /* this code reads it back for checking    */            
  362.     myIOParmBlk.ioPosMode = fsFromMark;
  363.     myIOParmBlk.ioPosMode = fsFromStart;
  364.     myIOParmBlk.ioPosOffset = NIL;
  365.     theErr = PBSetFPos(&myIOParmBlk, FALSE);
  366.     myIOParmBlk.ioPosMode = fsAtMark;
  367.  
  368.     myIOParmBlk.ioReqCount = nBytes;
  369.     myIOParmBlk.ioPosMode = fsAtMark;
  370.     myIOParmBlk.ioPosOffset = NIL;
  371.     myIOParmBlk.ioBuffer = (Ptr)SampsPtr;
  372.     if ( (theErr = PBRead(&myIOParmBlk, FALSE)) != noErr ) { 
  373.             PstringCopy((char *)theMess1, "\pError reading back sample file");
  374.             OSError(theMess1, NIL, NIL);
  375.     }
  376.     if ( myIOParmBlk.ioActCount != nBytes ) {
  377.             PstringCopy((char *)theMess1, "\pError reading back sample file wrote wrong number of bytes");
  378.             OSError(theMess1, NIL, NIL);
  379.     }
  380.     
  381. }
  382.  
  383.  
  384. void    DisplayDialog(GetSelection)
  385.     DialogPtr    GetSelection;
  386. {
  387.     DrawDialog(GetSelection);
  388.     GetDItem(GetSelection, 2, &type, &aHand, &prgBox);
  389.     FrameRect(&prgBox);
  390. }
  391.